home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update18.zoo / libg++ / src / xfix24.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-22  |  8.6 KB  |  353 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
  5.     adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. //
  21. // Fix24.cc : fixed precision class support functions
  22. //
  23.  
  24. #ifdef __GNUG__
  25. #pragma implementation
  26. #endif
  27. #include <xfix24.h>
  28.  
  29. // basic operators too large to be inline
  30.  
  31. long Fix24::assign(double d) 
  32. { 
  33.   if (d == 1.0)
  34.     return Fix24_m_max;
  35.   else if (d > Fix24_max)
  36.   {
  37.     long i = Fix24_m_max;
  38.     range_error(i);
  39.     return i;
  40.   }
  41.   else if (d < Fix24_min)
  42.   {
  43.     long i = Fix24_m_min;
  44.     range_error(i);
  45.     return i;
  46.   }
  47.   else {
  48.     d = (long) (d * (1 << 24) + ((d >= 0)? 0.5 : -0.5)); // Round to 24 bits
  49.     return ((long) d) << (Fix24_shift - 24);     /* Convert to integer format */
  50.   }
  51. }
  52.  
  53. twolongs Fix48::assign(double d) 
  54. { 
  55.   if (d == 1.0)
  56.     return Fix48_m_max;
  57.   else if (d > Fix48_max)
  58.   {
  59.     twolongs i = Fix48_m_max;
  60.     range_error(i);
  61.     return i;
  62.   }
  63.   else if (d < Fix48_min)
  64.   {
  65.     twolongs i = Fix48_m_min;
  66.     range_error(i);
  67.     return i;
  68.   }
  69.   else {
  70.     twolongs i;
  71.     int sign = (d < 0);
  72.  
  73. /* First, convert the absolute value of d to a 48-bit integer format */
  74.     if (d < 0) d = -d;
  75.     i.u = ((long)(d *= Fix24_mult)) & 0xffffff00;
  76.     i.l = ((unsigned long)((d - i.u)* (Fix24_mult / (1 << 7)))) & 0xffffff00;
  77.  
  78. /* Calculate the two's complement if d was negative */
  79.     if (sign) {
  80.     unsigned long oldlower = i.l;
  81.     i.l = (~i.l + 1) & 0xffffff00;
  82.     i.u = (~i.u + (((oldlower ^ i.l) & Fix24_msb)? 0 : 1)) & 0xffffff00;
  83.     }
  84.     return i;
  85.   }
  86. }
  87.  
  88.  
  89. Fix48 operator * (Fix24& a, Fix24& b)
  90. {
  91. // break a and b into lo and hi parts, and do a multiple-precision
  92. // multiply, with rounding
  93.  
  94.   int apos = (a.m >= 0);
  95.   unsigned long ua = (apos)? a.m : - a.m;
  96.   ua <<= 1; // ua is biased so result will be 47 bit mantissa, not 46:
  97.   unsigned long hi_a = (ua >> 16) & ((1 << 16) - 1);
  98.   unsigned long lo_a = ua & ((1 << 16) - 1);
  99.  
  100.   int bpos = (b.m >= 0);
  101.   unsigned long ub = (bpos)? b.m : -b.m;
  102.   unsigned long hi_b = (ub >> 16) & ((1 << 16) - 1);
  103.   unsigned long lo_b = ub & ((1 << 16) - 1);
  104.  
  105.   unsigned long 
  106.     hi_r = hi_a * hi_b,
  107.     mi_r = hi_a * lo_b + lo_a * hi_b,
  108.     lo_r = lo_a * lo_b,
  109.     rl = ((hi_r << 16) & 0x00ffffffL) + (mi_r & 0x00ffffffL) + (lo_r >> 16);
  110.   twolongs r;
  111.   r.u = (hi_r & 0xffffff00L) + ((mi_r >> 16) & 0x0000ff00L)
  112.     + ((rl >> 16) & 0x0000ff00L);
  113.   r.l = rl << 8;
  114.  
  115.   if ( apos != bpos ) {
  116.     unsigned long l = r.l;
  117.     r.l = -r.l;
  118.     r.u = (~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb)) & 0xffffff00;
  119.   }
  120.   return r;
  121. }
  122.  
  123. Fix24 operator / (Fix24& a, Fix24& b)
  124. {
  125.   long q;
  126.   int apos = (a.m >= 0);
  127.   unsigned long la = (apos)? a.m : -a.m;
  128.   int bpos = (b.m >= 0);
  129.   unsigned long lb = (bpos)? b.m: -b.m;
  130.   if (la >= lb)
  131.   {
  132.     q = (apos == bpos)? Fix24_m_max: Fix24_m_min;
  133.     a.range_error(q);
  134.   }
  135.   else                        // standard shift-based division alg
  136.   {
  137.     q = 0;
  138.     long r = la;
  139.  
  140.     for (int i = 32; i > 0; i--)
  141.     {
  142.     if ((unsigned long)(r) > lb) {
  143.         q = (q << 1) | 1;
  144.         r -= lb;
  145.     }
  146.     else
  147.         q = (q << 1);
  148.     r <<= 1;
  149.     }
  150.  
  151.     q += 0x80;            // Round result to 24 bits
  152.     if (apos != bpos) q = -q;    // Fix sign
  153.   }
  154.   return (q & 0xffffff00);
  155. }
  156.  
  157.  
  158. Fix48 operator + (Fix48&  f, Fix48&  g)
  159. {
  160.   long lo_r = (f.m.l >> 8) + (g.m.l >> 8);
  161.   twolongs r;
  162.   r.u = f.m.u + g.m.u + (lo_r & 0x01000000L ? 0x00000100L : 0);
  163.   r.l =  lo_r << 8;
  164.  
  165.   if ( (f.m.u ^ r.u) & (g.m.u ^ r.u) & Fix24_msb )
  166.     f.overflow(r);
  167.   return r;
  168. }
  169.  
  170. Fix48 operator - (Fix48&  f, Fix48&  g)
  171. {
  172.   unsigned lo_r = (f.m.l >> 8) - (g.m.l >> 8);
  173.   twolongs r;
  174.   r.u = f.m.u - g.m.u - (lo_r & 0x01000000L ? 0x00000100L: 0);
  175.   r.l = lo_r << 8;
  176.  
  177.   if ( ((f.m.u ^ r.u) & (-g.m.u ^ r.u) & Fix24_msb) && g.m.u )
  178.     f.overflow(r);
  179.   return r;
  180. }
  181.  
  182. Fix48 operator * (Fix48& a, long b)
  183. {
  184.   twolongs r;
  185.   int bpos = (b >= 0);
  186.   unsigned ub = (bpos)? b : -b;
  187.   if ( ub >= 65536L ) {
  188.     r = (bpos)? Fix48_m_max : Fix48_m_min;
  189.     a.range_error(r);
  190.   }
  191.   else {
  192.     unsigned long 
  193.       lo_r = (a.m.l & 0xffff) * ub,
  194.       mi_r = ((a.m.l >> 16) & 0xffff) * ub,
  195.       hi_r = a.m.u * ub;
  196.     r.l = lo_r + (mi_r << 16);
  197.     r.u = hi_r + ((mi_r >> 8) & 0x00ffff00L);
  198.     if ( !bpos ) {
  199.       unsigned long l = r.l;
  200.       r.l = -r.l;
  201.       r.u = ~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb);
  202.     }
  203.   }
  204.   return r;
  205. }
  206.  
  207. Fix48 operator * (Fix48& a, int b)
  208. {
  209.   twolongs r;
  210.   int bpos = (b >= 0);
  211.   unsigned ub = (bpos)? b : -b;
  212.   if ( ub >= 65536L ) {
  213.     r = (bpos)? Fix48_m_max : Fix48_m_min;
  214.     a.range_error(r);
  215.   }
  216.   else {
  217.     unsigned long 
  218.       lo_r = (a.m.l & 0xffff) * ub,
  219.       mi_r = ((a.m.l >> 16) & 0xffff) * ub,
  220.       hi_r = a.m.u * ub;
  221.     r.l = lo_r + (mi_r << 16);
  222.     r.u = hi_r + ((mi_r >> 8) & 0x00ffff00L);
  223.     if ( !bpos ) {
  224.       unsigned long l = r.l;
  225.       r.l = -r.l;
  226.       r.u = ~r.u + ((l ^ r.l) & Fix24_msb ? 0 : Fix24_lsb);
  227.     }
  228.   }
  229.   return r;
  230. }
  231.  
  232. Fix48 operator << (Fix48& a, int b)
  233. {
  234.   twolongs r; r.u = r.l = 0;
  235.   if ( b >= 0 )
  236.     if ( b < 24 ) {
  237.       r.u = (a.m.u << b) + ((a.m.l >> (24 - b)) & 0xffffff00L);
  238.       r.l = a.m.l << b;
  239.     }
  240.     else if ( b < 48 ) {
  241.       r.u = a.m.l << (b - 24);
  242.     }
  243.   return r;
  244. }
  245.  
  246. Fix48 operator >> (Fix48& a, int b)
  247. {
  248.   twolongs r; r.u = r.l = 0;
  249.   if ( b >= 0 )
  250.     if ( b < 24 ) {
  251.       r.l = (a.m.u << (24 - b)) + ((a.m.l >> b) & 0xffffff00L);
  252.       r.u = (a.m.u >> b) & 0xffffff00L;
  253.     }
  254.     else if ( b < 48 ) {
  255.       r.l = (a.m.u >> (b - 24)) & 0xffffff00L;
  256.       r.u = (a.m.u >> 24) & 0xffffff00L;
  257.     }
  258.     else {
  259.       r.l = (a.m.u >> 24) & 0xffffff00L;
  260.       r.u = r.l;
  261.     }
  262.   return r;
  263. }
  264.  
  265. // error handling
  266.  
  267. void Fix24::overflow(long& i)
  268. {
  269.   (*Fix24_overflow_handler)(i);
  270. }
  271.  
  272. void Fix48::overflow(twolongs& i)
  273. {
  274.   (*Fix48_overflow_handler)(i);
  275. }
  276.  
  277. void Fix24::range_error(long& i)
  278. {
  279.   (*Fix24_range_error_handler)(i);
  280. }
  281.  
  282. void Fix48::range_error(twolongs& i)
  283. {
  284.   (*Fix48_range_error_handler)(i);
  285. }
  286.  
  287. // data definitions
  288.  
  289. Fix24_peh Fix24_overflow_handler = Fix24_overflow_saturate;
  290. Fix48_peh Fix48_overflow_handler = Fix48_overflow_saturate;
  291.  
  292. Fix24_peh Fix24_range_error_handler = Fix24_warning;
  293. Fix48_peh Fix48_range_error_handler = Fix48_warning;
  294.  
  295. //function definitions
  296.  
  297. Fix24_peh set_Fix24_overflow_handler(Fix24_peh new_handler) {
  298.   Fix24_peh old_handler = Fix24_overflow_handler;
  299.   Fix24_overflow_handler = new_handler;
  300.   return old_handler;
  301. }
  302.  
  303. Fix48_peh set_Fix48_overflow_handler(Fix48_peh new_handler) {
  304.   Fix48_peh old_handler = Fix48_overflow_handler;
  305.   Fix48_overflow_handler = new_handler;
  306.   return old_handler;
  307. }
  308.  
  309. void set_overflow_handler(Fix24_peh handler24, Fix48_peh handler48) {
  310.   set_Fix24_overflow_handler(handler24);
  311.   set_Fix48_overflow_handler(handler48);
  312. }
  313.  
  314. Fix24_peh set_Fix24_range_error_handler(Fix24_peh new_handler) {
  315.   Fix24_peh old_handler = Fix24_range_error_handler;
  316.   Fix24_range_error_handler = new_handler;
  317.   return old_handler;
  318. }
  319.  
  320. Fix48_peh set_Fix48_range_error_handler(Fix48_peh new_handler) {
  321.   Fix48_peh old_handler = Fix48_range_error_handler;
  322.   Fix48_range_error_handler = new_handler;
  323.   return old_handler;
  324. }
  325.  
  326. void set_range_error_handler(Fix24_peh handler24, Fix48_peh handler48) {
  327.   set_Fix24_range_error_handler(handler24);
  328.   set_Fix48_range_error_handler(handler48);
  329. }
  330.  
  331. void Fix24_overflow_saturate(long& i)
  332.   { i = (i > 0 ? Fix24_m_min : Fix24_m_max); }
  333. void Fix24_ignore(long&) {}
  334. void Fix24_warning(long&)
  335.   { cerr << "warning: Fix24 result out of range\n"; }
  336. void Fix24_overflow_warning_saturate(long& i)
  337.   { cerr << "warning: Fix24 result out of range\n"; 
  338.    Fix24_overflow_saturate(i); }
  339. void Fix24_abort(long&)
  340.   { cerr << "error: Fix24 result out of range\n"; abort(); }
  341.  
  342. void Fix48_ignore(twolongs&) {}
  343. void Fix48_overflow_saturate(twolongs& i)
  344.   { i = (i.u > 0 ? Fix48_m_min : Fix48_m_max); }
  345. void Fix48_warning(twolongs&)
  346.   { cerr << "warning: Fix48 result out of range\n"; }
  347. void Fix48_overflow_warning_saturate(twolongs& i)
  348.   { cerr << "warning: Fix48 result out of range\n"; 
  349.    Fix48_overflow_saturate(i); }
  350. void Fix48_abort(twolongs&)
  351.   { cerr << "error: Fix48 result out of range\n"; abort(); }
  352.  
  353.